TypeScript Serializacija: JSON Tipo Saugumo Šablonai

Nuolat besikeičiančioje interneto kūrimo srityje, duomenų vientisumo užtikrinimas ir vykdymo klaidų prevencija yra svarbiausi dalykai. TypeScript, su savo tvirta tipo sistema, suteikia galingą mechanizmą šiems tikslams pasiekti, ypač kai dirbama su JSON serializacija ir deserializacija. Šis išsamus vadovas nagrinėja įvairius šablonus ir technikas, skirtas įgyvendinti tipo saugų JSON apdorojimą jūsų TypeScript projektuose, leidžiantį jums kurti patikimesnes ir lengviau prižiūrimas aplikacijas globaliai auditorijai.

Problemos Supratimas: JSON ir TypeScript Tipo Sistema

JSON (JavaScript Object Notation) yra de facto standartas duomenų mainams internete. Tačiau JSON iš prigimties netipizuotas pobūdis kelia iššūkių, kai integruojamas su statiškai tipizuota kalba, tokia kaip TypeScript. Be tinkamo tipo vykdymo, kūrėjai rizikuoja susidurti su vykdymo klaidomis dėl tipo neatitikimų, netikėtų duomenų formatų ar trūkstamų laukų. Tai gali sukelti aplikacijos gedimus, saugumo pažeidžiamumus ir nusivylusius vartotojus visame pasaulyje.

Įsivaizduokite scenarijų, kai gaunate duomenis iš viešosios API. API dokumentacijoje teigiama, kad konkretus galinis taškas grąžina vartotojo objektų masyvą, kurių kiekvienas turi `id`, `name` ir `email` savybes. Be tipo saugumo, galite manyti, kad duomenų struktūra yra tokia, kaip aprašyta, ir pradėti ją naudoti savo aplikacijoje. Tačiau kas nutiks, jei API pakeis savo atsakymo formatą, įves naujus laukus arba pakeis esamų laukų duomenų tipus? Jūsų aplikacija gali sugesti, o tai sukels prastą vartotojo patirtį.

TypeScript išsprendžia šią problemą leisdamas jums apibrėžti sąsajas ar tipus, kurie atspindi jūsų JSON duomenų struktūrą. Tai leidžia TypeScript kompiliatoriui patikrinti tipo klaidas kompiliavimo metu, užkertant kelią daugeliui galimų vykdymo problemų. Užtikrinant tipo saugumą serializacijos ir deserializacijos metu, galite žymiai pagerinti savo kodo bazės patikimumą ir prižiūrimumą.

Pagrindinės Koncepcijos ir Technikos

1. TypeScript Sąsajų ir Tipų Apibrėžimas

Tipo saugaus JSON apdorojimo pagrindas yra TypeScript sąsajų ar tipų, kurie tiksliai modeliuoja jūsų JSON duomenų struktūrą, apibrėžimas. Sąsaja apibrėžia objekto formos sutartį, nurodydama jo savybių duomenų tipus. Tipo aliasas suteikia glaustesnį būdą kurti pasirinktinius tipus.

Pavyzdys:

            interface User {
  id: number;
  name: string;
  email: string;
  isActive: boolean;
  address?: { //Optional property
      street: string;
      city: string;
      country: string;
  }
}

//Alternatively using type
type UserType = {
  id: number;
  name: string;
  email: string;
  isActive: boolean;
  address?: {
      street: string;
      city: string;
      country: string;
  }
}

            

              
                Copy
              
            
          

Šiame pavyzdyje `User` sąsaja apibrėžia numatomą vartotojo objekto struktūrą. Savybė `address` yra pasirinktinė, pažymėta `?` simboliu, kuris yra dažnas šablonas tvarkant potencialiai trūkstamus duomenis. Sąsajų ir tipo aliasų naudojimas suteikia tipo tikrinimą kompiliavimo metu, sumažinant vykdymo klaidų riziką dirbant su JSON duomenimis.

2. Serializacija: TypeScript Objektų Konvertavimas į JSON

Serializacija yra TypeScript objekto konvertavimo į JSON eilutę procesas. Tai paprastai atliekama siunčiant duomenis į serverį arba saugant juos duomenų bazėje. TypeScript tipo sistema suteikia kompiliavimo metu garantijas, kad objektas atitinka apibrėžtą tipą, užkertant kelią netikėtoms klaidoms. Įmontuotas `JSON.stringify()` metodas naudojamas serializacijai. Tačiau svarbu atsižvelgti į kraštutinius atvejus, tokius kaip pasirinktiniai objektų tipai arba datos objektai serializacijos metu.

Pavyzdys:

            const user: User = {
  id: 123,
  name: 'John Doe',
  email: 'john.doe@example.com',
  isActive: true,
  address: {
      street: '123 Main St',
      city: 'Anytown',
      country: 'USA'
  }
};

const userJSON: string = JSON.stringify(user, null, 2); // Pretty-printed JSON with 2 spaces for indentation
console.log(userJSON);

            

              
                Copy
              
            
          

Šis kodo fragmentas parodo, kaip serializuoti `User` objektą į JSON eilutę naudojant `JSON.stringify()`. Antrasis argumentas, `null`, yra pakeitimo funkcija, leidžianti jums tinkinti serializacijos procesą. Trečiasis argumentas, `2`, nurodo tarpų skaičių, kuris bus naudojamas įtraukoms, todėl JSON išvestis tampa lengviau skaitoma. Realiame pasaulyje, apsvarstykite klaidų, kurios gali atsirasti `JSON.stringify()` metu, tvarkymą ir tinkinkite jį, kad apdorotumėte Date objektus ir kitus specialius tipus.

3. Deserializacija: JSON Eilučių Konvertavimas į TypeScript Objektus

Deserializacija yra JSON eilutės konvertavimo atgal į TypeScript objektą procesas. Tai dažniausiai atliekama gaunant duomenis iš serverio arba skaitant juos iš failo. Čia tipo saugumas yra labai svarbus. Tiesioginis `JSON.parse()` rezultato priskyrimas jūsų apibrėžtai sąsajai automatiškai neatliks tipo validacijos. Jis tik pasako kompiliatoriui „pasitikėti“, kad duomenys yra nurodyto tipo. Bet koks neatitikimas tarp duomenų ir sąsajos sukels vykdymo klaidas.

Norint saugiai deserializuoti JSON, yra keli būdai, kurių kiekvienas turi savo privalumų ir trūkumų. Tai apima kruopščią duomenų validaciją, siekiant užtikrinti, kad gaunami JSON duomenys atitiktų numatomą struktūrą ir duomenų tipus.

3.1 Tiesioginis Priskyrimas (atsargiai)

Šis būdas apima tipo teiginio naudojimą, kad `JSON.parse()` rezultatas būtų priskirtas jūsų sąsajai. Tai yra paprasčiausias, bet ir rizikingiausias būdas deserializuoti JSON duomenis, nes jis neatlieka vykdymo validacijos. Jis tiesiog informuoja kompiliatorių, kad duomenys atitinka tipą. Šis metodas veikia, kai jūs *pasitikite* JSON šaltiniu, pvz., iš savo vidinės API arba kodo, kurį kontroliuojate.

Pavyzdys:

            const userJSON: string = '{
  "id": 123,
  "name": "Jane Doe",
  "email": "jane.doe@example.com",
  "isActive": true
}';

const user: User = JSON.parse(userJSON) as User;
console.log(user.name);

            

              
                Copy
              
            
          

Šiame pavyzdyje `JSON.parse(userJSON)` rezultatas yra priskirtas `User` sąsajai. Nors tai kompiliuojama be klaidų, jei `userJSON` eilutė neatitinka `User` sąsajos (pvz., trūksta savybės arba neteisingas duomenų tipas), susidursite su vykdymo klaidomis, kai pasieksite savybes.

3.2 Validacija su Bibliotekomis (Rekomenduojama)

Naudoti specialią validacijos biblioteką yra rekomenduojamas būdas tipo saugiai deserializacijai. Tokios bibliotekos kaip `zod`, `io-ts` ir `class-validator` suteikia tvirtas funkcijas JSON duomenų validavimui pagal apibrėžtą schemą. Šios bibliotekos leidžia jums apibūdinti numatomą struktūrą ir duomenų tipus ir automatiškai validuoti duomenis vykdymo metu, pateikiant išsamius klaidų pranešimus, jei validacija nepavyksta.

Naudojant Zod: Zod yra populiari biblioteka schemos validacijai su paprasta ir intuityvia API. Lengva apibrėžti schemas ir validuoti duomenis pagal jas. Pirmiausia įdiekite Zod:

            npm install zod
            

              
                Copy
              
            
          

Tada naudokite Zod, kad apibrėžtumėte schemą, atitinkančią jūsų sąsają. Tarkime, kad turime `User` sąsają, apibrėžtą aukščiau.

            import { z } from 'zod';

const UserSchema = z.object({
  id: z.number(),
  name: z.string(),
  email: z.string().email(), // Email validation
  isActive: z.boolean(),
  address: z.optional(z.object({
    street: z.string(),
    city: z.string(),
    country: z.string()
  }))
});

interface User {
  id: number;
  name: string;
  email: string;
  isActive: boolean;
  address?: {
    street: string;
    city: string;
    country: string;
  }
}

            

              
                Copy
              
            
          

Dabar galime analizuoti ir validuoti JSON eilutę:

            const userJSON: string = '{
  "id": 123,
  "name": "John Doe",
  "email": "john.doe@example.com",
  "isActive": true
}';

try {
    const parsedUser: User = UserSchema.parse(JSON.parse(userJSON));
    console.log(parsedUser.name);
} catch (error: any) {
    console.error('Validation error:', error.errors);
}

            

              
                Copy
              
            
          

Šiame pavyzdyje `UserSchema.parse(JSON.parse(userJSON))` bando analizuoti ir validuoti `userJSON` eilutę. Jei duomenys neatitinka schemos, išmetamas `ZodError`, leidžiantis jums tvarkyti validacijos klaidas grakščiai. `try...catch` blokas tvarko visas validacijos klaidas, kurios gali atsirasti. Tai yra saugesnis ir patikimesnis metodas deserializuoti JSON duomenis.

Naudojant io-ts: io-ts yra biblioteka, kuri sujungia vykdymo tipo tikrinimą su funkcinio programavimo koncepcijomis. Tai leidžia jums apibrėžti kodekus, kurie koduoja ir dekoduoja duomenis, ir validuoti JSON duomenis pagal šiuos kodekus. Pradėti su juo yra sudėtingiau, tačiau jis suteikia galingesnes funkcijas sudėtingiems validacijos scenarijams.

            npm install io-ts

            

              
                Copy
              
            
          

            import * as t from 'io-ts';
import { isRight } from 'fp-ts/lib/Either';

const UserCodec = t.type({
  id: t.number,
  name: t.string,
  email: t.string,
  isActive: t.boolean,
  address: t.union([ //using union to represent either address or undefined
    t.undefined,
    t.type({
        street: t.string,
        city: t.string,
        country: t.string
    })
  ])
});

interface User {
  id: number;
  name: string;
  email: string;
  isActive: boolean;
  address?: {
    street: string;
    city: string;
    country: string;
  }
}


const userJSON: string = '{
  "id": 123,
  "name": "John Doe",
  "email": "john.doe@example.com",
  "isActive": true
}';

const decoded = UserCodec.decode(JSON.parse(userJSON));

if (isRight(decoded)) {
  const user: User = decoded.right;
  console.log(user.name);
} else {
  console.error('Validation errors:', decoded.left);
}

            

              
                Copy
              
            
          

Šiame pavyzdyje `UserCodec.decode(JSON.parse(userJSON))` bando dekoduoti ir validuoti `userJSON` eilutę. `isRight()` iš `fp-ts` bibliotekos tikrina validacijos rezultatą, o validacijos klaidos pateikiamos, jei dekoduotas JSON neatitinka `UserCodec`.

Tokios bibliotekos kaip `zod` ir `io-ts` siūlo privalumus tipo saugioje JSON deserializacijoje, suteikdamos:

• Vykdymo Validacija: Jos validuoja duomenis pagal schemą vykdymo metu, nustatydamos klaidas prieš joms sukeliant problemų.
• Aiškūs Klaidų Pranešimai: Jos pateikia konkrečius, naudingus klaidų pranešimus, kad nustatytų duomenų validacijos problemas.
• Tipo Išvedimas: Jos dažnai gerai veikia su TypeScript tipo išvedimu, todėl tipo apibrėžimus lengviau prižiūrėti.

3.3 Pasirinktinės Deserializacijos Funkcijos

Kitas būdas yra rašyti pasirinktines deserializacijos funkcijas, kurios tvarko JSON duomenų konvertavimą į jūsų TypeScript sąsajas. Tai leidžia jums tvarkyti specifinius duomenų tipus arba transformacijas, kurių lengvai nepasieksite su paprastesnėmis validacijos bibliotekomis. Šis būdas suteikia didesnę kontrolę, tačiau reikalauja daugiau pastangų.

Pavyzdys:

            interface User {
  id: number;
  name: string;
  email: string;
  isActive: boolean;
  createdAt: Date;
}

function deserializeUser(json: string): User | null {
  try {
    const parsed = JSON.parse(json);

    if (
      typeof parsed.id !== 'number' ||
      typeof parsed.name !== 'string' ||
      typeof parsed.email !== 'string' ||
      typeof parsed.isActive !== 'boolean' ||
      typeof parsed.createdAt !== 'string'
    ) {
      return null; // Invalid data
    }

    // Assuming createdAt is a string in ISO format
    const createdAtDate = new Date(parsed.createdAt);
    if (isNaN(createdAtDate.getTime())) {
      return null; //Invalid date
    }

    return {
      id: parsed.id,
      name: parsed.name,
      email: parsed.email,
      isActive: parsed.isActive,
      createdAt: createdAtDate,
    };
  } catch (error) {
    console.error('Deserialization error:', error);
    return null;
  }
}

const userJSON: string = '{
  "id": 123,
  "name": "John Doe",
  "email": "john.doe@example.com",
  "isActive": true,
  "createdAt": "2024-01-26T10:00:00.000Z"
}';

const user: User | null = deserializeUser(userJSON);

if (user) {
  console.log(user.name);
  console.log(user.createdAt);
} else {
  console.log('Invalid user data');
}

            

              
                Copy
              
            
          

Šiame pavyzdyje `deserializeUser` funkcija analizuoja JSON eilutę ir validuoja savybių duomenų tipus. Ji taip pat tvarko `createdAt` savybės konvertavimą iš eilutės į `Date` objektą. Jei duomenys yra neteisingi, funkcija grąžina `null`. Ši pasirinktinė funkcija suteikia visišką kontrolę deserializacijos procesui, leidžiant jums tvarkyti sudėtingas duomenų transformacijas.

4. Pasirinktinių Savybių ir Null Reikšmių Tvarkymas

JSON duomenys dažnai apima pasirinktines savybes ir null reikšmes. TypeScript tipo sistema suteikia mechanizmus, kaip grakščiai tvarkyti šiuos atvejus. Pasirinktinės savybės yra pažymėtos `?` priesaga sąsajos apibrėžime. `null` reikšmės reikalauja kruopštaus svarstymo deserializacijos metu. Kai naudojate validacijos bibliotekas, tokias kaip Zod, galite apibrėžti pasirinktinius laukus su `z.optional()` arba `z.nullable()`, kad leistumėte tiek `null`, tiek undefined, priklausomai nuo API grąžintos JSON struktūros.

Pavyzdys:

            import { z } from 'zod';

const UserSchema = z.object({
  id: z.number(),
  name: z.string(),
  email: z.string().email(),
  isActive: z.boolean(),
  address: z.optional(z.object({
    street: z.string(),
    city: z.string(),
    country: z.string()
  })),
  profilePicture: z.nullable(z.string()) // Allows null values
});

interface User {
  id: number;
  name: string;
  email: string;
  isActive: boolean;
  address?: {
    street: string;
    city: string;
    country: string;
  };
  profilePicture: string | null; // Typescript interface reflects the nullable
}

const userJSONWithAddress: string = '{
  "id": 123,
  "name": "John Doe",
  "email": "john.doe@example.com",
  "isActive": true,
  "address": {
    "street": "123 Main St",
    "city": "Anytown",
    "country": "USA"
  },
  "profilePicture": "/path/to/image.jpg"
}';

const userJSONWithoutAddress: string = '{
  "id": 456,
  "name": "Jane Smith",
  "email": "jane.smith@example.com",
  "isActive": false,
  "profilePicture": null
}';

try {
    const userWithAddress: User = UserSchema.parse(JSON.parse(userJSONWithAddress));
    console.log(userWithAddress);

    const userWithoutAddress: User = UserSchema.parse(JSON.parse(userJSONWithoutAddress));
    console.log(userWithoutAddress);
} catch (error) {
    console.error("Validation error", error);
}

            

              
                Copy
              
            
          

Šiame pavyzdyje `address` savybė yra pasirinktinė. `profilePicture` gali turėti eilutės duomenis arba `null`. Zod arba panašūs validacijos įrankiai tvarko duomenų validaciją.

5. Generiniai Tipai Pakartotinai Naudojamai Serializacijai ir Deserializacijai

Generiniai tipai gali būti naudojami kuriant pakartotinai naudojamas serializacijos ir deserializacijos funkcijas, kurios veikia su įvairiais tipais. Tai sumažina kodo dubliavimą ir skatina kodo pakartotinį naudojimą. Generinių tipų naudojimas leidžia jums rašyti funkcijas, kurios gali veikti su skirtingais tipais, nereikalaujant rašyti atskirų funkcijų kiekvienam tipui.

Pavyzdys:

            import { z, ZodSchema } from 'zod';

function safeParse(schema: ZodSchema, json: string): T | null {
  try {
    const parsed = JSON.parse(json);
    return schema.parse(parsed);
  } catch (error) {
    console.error('Parse error:', error);
    return null;
  }
}

interface Product {
  id: number;
  name: string;
  price: number;
}

const ProductSchema: ZodSchema = z.object({
  id: z.number(),
  name: z.string(),
  price: z.number()
});

const productJSON: string = '{
  "id": 1,
  "name": "Example Product",
  "price": 99.99
}';

const product: Product | null = safeParse(ProductSchema, productJSON);

if (product) {
  console.log(product.name);
} else {
  console.log('Invalid product data');
}

            

              
                Copy
              
            
          

`safeParse` funkcija yra generinė funkcija, kuri priima Zod schemą ir JSON eilutę. Ji analizuoja JSON eilutę ir validuoja ją pagal pateiktą schemą. Jei analizavimas arba validacija nepavyksta, ji grąžina `null`. Ši generinė funkcija gali būti pakartotinai naudojama skirtingiems tipams tiesiog perduodant atitinkamą Zod schemą.

Geriausios Praktikos ir Išplėstiniai Svarstymai

1. Duomenų Validacijos Geriausios Praktikos

• Centralizuoti Schemų Apibrėžimai: Apibrėžkite savo schemas centrinėje vietoje, kad užtikrintumėte nuoseklumą ir prižiūrimumą.
• Išsami Validacija: Validuokite visas savybes ir duomenų tipus.
• Klaidų Tvarkymas: Įgyvendinkite tvirtą klaidų tvarkymą, kad pagautumėte ir praneštumėte apie validacijos klaidas.
• Schemų Versijavimas: Apsvarstykite schemų versijavimą, kai jūsų API arba duomenų struktūra vystosi. Tai leidžia jums palaikyti kelias duomenų formato versijas, sumažinant lūžtančius pakeitimus.
• Testavimas: Parašykite vienetinius testus savo serializacijos ir deserializacijos logikai, kad užtikrintumėte jos teisingumą ir patikimumą. Įtraukite testus teisingiems ir neteisingiems duomenų scenarijams.

2. Sudėtingų Duomenų Struktūrų Tvarkymas

Sudėtingoms duomenų struktūroms gali reikėti įdėti schemas arba naudoti rekursyvias schemas savo validacijos bibliotekoje. Sudėtingos struktūros gali būti atspindėtos naudojant įdėtas sąsajas arba komponuojant esamas schemas naudojant tokias bibliotekas kaip Zod arba io-ts.

Rekursyvios Schemos Pavyzdys su Zod:

            import { z } from 'zod';

interface TreeNode {
  value: string;
  children: TreeNode[];
}

const TreeNodeSchema: z.ZodSchema = z.object({
  value: z.string(),
  children: z.lazy(() => z.array(TreeNodeSchema)), // Recursive definition
});

const treeJSON: string = '{
  "value": "Root",
  "children": [
    {
      "value": "Child 1",
      "children": []
    },
    {
      "value": "Child 2",
      "children": [
        {
          "value": "Grandchild 1",
          "children": []
        }
      ]
    }
  ]
}';

try {
  const parsedTree: TreeNode = TreeNodeSchema.parse(JSON.parse(treeJSON));
  console.log(parsedTree);
} catch (error) {
  console.error("Validation error", error);
}

            

              
                Copy
              
            
          

Šis pavyzdys parodo, kaip apibrėžti rekursyvią schemą medžio tipo duomenų struktūrai naudojant Zod.

3. Veiklos Svarstymai

• Pasirinkite Tinkamą Biblioteką: Pasirinkite validacijos biblioteką, kuri atitinka jūsų veiklos reikalavimus. Tokios bibliotekos kaip `zod` ir `io-ts` paprastai veikia gerai, tačiau konkrečių bibliotekų veikimas gali skirtis.
• Optimizuokite Schemas: Kurkite schemas efektyviai. Venkite nereikalingų validacijos žingsnių.
• Kaupimas Talpykloje: Talpinkite serializuotus duomenis talpykloje, kai įmanoma, kad išvengtumėte pakartotinio serializacijos viršutinės ribos. Tačiau visada teikite pirmenybę duomenų teisingumui prieš našumą kritinėms aplikacijoms.

4. Saugumo Svarstymai

• Įvesties Valymas: Išvalykite visus vartotojo pateiktus duomenis prieš serializaciją, kad išvengtumėte įterpimo pažeidžiamumų. Tai yra esminis saugaus kodavimo aspektas, užtikrinantis, kad kenkėjiškas kodas nebūtų serializuotas ar deserializuotas.
• Duomenų Validacija: Kruopščiai validuokite duomenis, kad išvengtumėte pažeidžiamumų. Tvirtas validavimas padeda apsisaugoti nuo atakų, kai kenkėjiški aktoriai bando pateikti neteisingus duomenis, kad sukeltų klaidų ar saugumo pažeidimų.
• Venkite `eval()` ir `new Function()`: Niekada nenaudokite `eval()` arba `new Function()` su nepatikimais JSON duomenimis. Šie metodai gali sukelti didelių saugumo rizikų, leisdami vykdyti savavališką kodą.

5. Internacionalizacija ir Lokalizacija

Kuriant globalias aplikacijas, apsvarstykite serializacijos ir deserializacijos poveikį internacionalizacijai (i18n) ir lokalizacijai (l10n). Skirtingi regionai naudoja skirtingus datos/laiko formatus, valiutos simbolius ir skaičių formatavimo taisykles. Jūsų serializacijos ir deserializacijos logika turėtų sugebėti tvarkyti šiuos skirtumus. Tokios bibliotekos kaip Moment.js arba date-fns dažnai naudojamos datos ir laiko formatavimui tvarkyti. Apsvarstykite galimybę naudoti `Intl` objektą JavaScript, kad formatuotumėte skaičius ir valiutas, kad palaikytumėte skirtingas lokalės.

Išvada: Patikimų Aplikacijų Kūrimas Globaliai

TypeScript tipo sistema, kartu su tvirtomis validacijos bibliotekomis, suteikia kūrėjams galimybę kurti patikimesnes ir lengviau prižiūrimas aplikacijas, suteikiant išsamų tipo saugų JSON apdorojimą. Pritaikydami šablones ir technikas, aprašytas šiame vadove, galite sumažinti vykdymo klaidas, pagerinti duomenų vientisumą ir užtikrinti savo interneto aplikacijų stabilumą vartotojams visame pasaulyje. Tipo saugumo priėmimas ne tik naudingas jūsų kūrimo komandai gerinant kodo kokybę, bet ir pagerina vartotojo patirtį užkertant kelią netikėtoms klaidoms ir užtikrinant nuoseklų duomenų atvaizdavimą, prisidedant prie tvirtesnės ir patikimesnės aplikacijos globaliai.

Šių šablonų įgyvendinimas, nuo sąsajų apibrėžimo ir validacijos bibliotekų, tokių kaip Zod ir io-ts, naudojimo iki pasirinktinių savybių ir null reikšmių tvarkymo, leis sukurti tvirtesnį ir lengviau prižiūrimą kodą. Nepamirškite teikti pirmenybę išsamiai validacijai, klaidų tvarkymui ir saugumo geriausioms praktikoms. Pritaikydami šias praktikas, kūrėjai gali kurti aplikacijas, kurios yra atsparesnės klaidoms, lengviau prižiūrimos ir suteikia geresnę vartotojo patirtį visuose regionuose ir kultūrose.